package com.rzjm.api.util.redis;

import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.connection.RedisClusterNode;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisServerCommands;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationUtils;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author wx
 * @date 2021/12/7 8:44 下午
 * @describe redis工具类
 */
@Slf4j
public class RedisUtil {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;


    public RedisUtil(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * 获取链接工厂
     */
    public RedisConnectionFactory getConnectionFactory() {
        return this.redisTemplate.getConnectionFactory();
    }

    /**
     * 获取 RedisTemplate对象
     */
    public RedisTemplate<String, Object> getRedisTemplate() {
        return redisTemplate;
    }


    /**
     * 清空DB
     *
     * @param node redis 节点
     */
    public void flushDB(RedisClusterNode node) {
        this.redisTemplate.opsForCluster().flushDb(node);
    }

    /**
     * 获取指定key的过期时间
     *
     * @param key 缓存key
     */
    public Long getExpire(final String key) {
        return this.redisTemplate.getExpire(key);
    }

    /**
     * 添加到带有 过期时间的  缓存
     *
     * @param key      redis主键
     * @param value    值
     * @param time     过期时间
     * @param timeUnit 过期时间单位
     */
    public void setExpire(final String key, final Object value, final long time, final TimeUnit timeUnit) {
        redisTemplate.opsForValue().set(key, value, time, timeUnit);
    }

    /**
     * 添加 缓存、值并设置过期时间，默认过期单位，秒
     *
     * @param key
     * @param value
     * @param time
     */
    public void setExpire(final String key, final Object value, final long time) {
        this.setExpire(key, value, time, TimeUnit.SECONDS);
    }

    /**
     * 单独给某个key设置过期时间（缓存中已存在的key）
     *
     * @param key
     * @param time
     * @param timeUnit
     */
    public void expire(final String key, final long time, final TimeUnit timeUnit) {
        redisTemplate.expire(key, time, timeUnit);
    }

    /**
     * 一次性添加数组到   过期时间的  缓存，不用多次连接，节省开销
     *
     * @param keys   the keys
     * @param values the values
     */
    public void setKeys(final String[] keys, final Object[] values) {
        //key和value数组之间索引对应
        for (int i = 0; i < keys.length; i++) {
            redisTemplate.opsForValue().set(keys[i], values[i]);
        }
    }


    /**
     * 添加到缓存key-value格式
     *
     * @param key   the key
     * @param value the value
     */
    public void setKey(final String key, final Object value) {
        redisTemplate.opsForValue().set(key, value);
    }


    /**
     * 模糊获取keyPatten的所有  key
     *
     * @param keyPatten the key patten
     * @return the set
     */
    public Set<String> getKeys(final String keyPatten) {
        return redisTemplate.keys(keyPatten + "*");
    }

    /**
     * 根据key获取对象value
     *
     * @param key the key
     * @return the string
     */
    public Object getValue(final String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 获取指定key原来的value并重新赋值
     *
     * @param key
     * @param newValue 新value
     * @return 旧的value
     */
    public Object getAndSet(final String key, final Object newValue) {
        return redisTemplate.opsForValue().getAndSet(key, newValue);
    }

    /**
     * 根据keyList获取所有key的value对象
     *
     * @param keyList 集合key
     * @return
     */
    public List<Object> multiGet(List<String> keyList) {
        return redisTemplate.opsForValue().multiGet(keyList);
    }


    /**
     * 针对hashMap数据结构的相关操作
     *
     * @return the hash operations
     */
    public HashOperations<String, String, Object> opsForHash() {
        return redisTemplate.opsForHash();
    }

    /**
     * 对HashMap操作
     *
     * @param key       缓存redis中的key
     * @param hashKey   Map<key,value>数据结构中的key
     * @param hashValue Map<key,value>数据结构中的value
     */
    public void putHashValue(String key, String hashKey, Object hashValue) {
        this.opsForHash().put(key, hashKey, hashValue);
    }


    /**
     * 获取hashMap结构中指定hashKey对应的hashValue值
     *
     * @param key     缓存的key
     * @param hashKey Map<key,value>数据结构中的key
     * @return the hash values
     */
    public Object getHashValues(String key, String hashKey) {
        return opsForHash().get(key, hashKey);
    }

    /**
     * 删除指定key中hashMap中的若干元素
     *
     * @param key      the key
     * @param hashKeys the hash keys
     */
    public void delHashValues(String key, Object... hashKeys) {
        this.opsForHash().delete(key, hashKeys);
    }

    /**
     * 获取指定key的hashMap数据元素
     *
     * @param key the key
     * @return the hash value
     */
    public Map<String, Object> getHashValue(String key) {
        return this.opsForHash().entries(key);
    }


    /**
     * 批量添加hashMap数据元素
     *
     * @param key the key
     * @param map the map
     */
    public void putHashValues(String key, Map<String, Object> map) {
        opsForHash().putAll(key, map);
    }


    /**
     * 集合数量
     *
     * @return the long
     */
    public long dbSize() {
        return redisTemplate.execute(RedisServerCommands::dbSize);
    }

    /**
     * 清空redis存储的数据
     *
     * @return the string
     */
    public String flushDB() {
        return redisTemplate.execute((RedisCallback<String>) connection -> {
            connection.flushDb();
            return "ok";
        });
    }

    /**
     * 判断某个主键是否存在
     *
     * @param key the key
     * @return the boolean
     */
    public boolean exists(final String key) {
        return this.redisTemplate.hasKey(key);
    }


    /**
     * 删除key
     *
     * @param keys the keys
     * @return the long
     */
    public boolean del(final String... keys) {
        boolean result = false;
        for (String key : keys) {
            result = redisTemplate.delete(key);
        }
        return result;
    }

    /**
     * 对某个主键对应的值加一,value值必须是全数字的字符串
     *
     * @param key the key
     * @return the long
     */
    public long incrValue(final String key, final long addValue) {
        return redisTemplate.opsForValue().increment(key, addValue);
    }


    /**
     * 对某个主键对应的值减一,value值必须是全数字的字符串
     *
     * @param key the key
     * @return the long
     */
    public long decrValue(final String key) {
        return redisTemplate.opsForValue().decrement(key);
    }


    /**
     * List数据结构相关操作
     *
     * @return the list operations
     */
    public ListOperations<String, Object> opsForList() {
        return redisTemplate.opsForList();
    }

    /**
     * redis List数据结构 : 将一个或多个值 value 插入到列表 key 的表头
     *
     * @param key   the key
     * @param value the value
     * @return the long
     */
    public Long leftPush(String key, Object value) {
        return opsForList().leftPush(key, value);
    }

    /**
     * redis List数据结构 : 移除并返回列表 key 的头元素
     *
     * @param key the key
     * @return the string
     */
    public Object leftPop(String key) {
        return opsForList().leftPop(key);
    }

    /**
     * redis List数据结构 :将一个或多个值 value 插入到列表 key 的表尾(最右边)。
     *
     * @param key   the key
     * @param value the value
     * @return the long
     */
    public Long rightPush(String key, Object value) {
        return opsForList().rightPush(key, value);
    }

    /**
     * redis List数据结构 : 移除并返回列表 key 的末尾元素
     *
     * @param key the key
     * @return the string
     */
    public Object rightPop(String key) {
        return opsForList().rightPop(key);
    }

    /**
     * redis List数据结构 : 返回列表 key 的长度 ;
     * 如果 key 不存在，则 key 被解释为一个空列表，返回 0 ;
     * 如果 key 不是列表类型，返回一个错误。
     *
     * @param key the key
     * @return the long
     */
    public Long listLength(String key) {
        return opsForList().size(key);
    }

    /**
     * redis List数据结构：移除指定个数count的value
     *
     * @param key   要移除元素的key
     * @param count 移除个数，count==0，移除list中所有指定value的元素；
     *              count<0,从表尾向表头移动，移除count绝对值的value元素；
     *              count>0 ,从表头向表尾移动，移除count的value元素；
     * @param value 移除的value
     * @return
     */
    public Long removeListValues(String key, Long count, Object value) {
        return this.opsForList().remove(key, count, value);
    }

    /**
     * redis List数据结构 : 将列表 key 下标为 index 的元素的值设置为 value
     *
     * @param key   the key
     * @param index the index
     * @param value the value
     */
    public void listSetValue(String key, long index, Object value) {
        opsForList().set(key, index, value);
    }

    /**
     * redis List数据结构 : 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 end 指定。
     *
     * @param key   the key
     * @param start the start
     * @param end   the end
     * @return the list
     */
    public List<Object> getList(String key, int start, int end) {
        return opsForList().range(key, start, end);
    }

    /**
     * redis List数据结构 : 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 end 指定。
     *
     * @param key             the key
     * @param start           the start
     * @param end             the end
     * @param valueSerializer 序列化
     * @return the list
     */
    public List<Object> getList(String key, int start, int end, RedisSerializer<Object> valueSerializer) {
        byte[] rawKey = rawKey(key);
        return redisTemplate.execute(connection -> deserializeValues(connection.lRange(rawKey, start, end), valueSerializer), true);
    }


    /**
     * redis List数据结构 : 批量存储
     *
     * @param key  the key
     * @param list the list
     * @return the long
     */
    public Long leftPushAll(String key, Object[] list) {
        return opsForList().leftPushAll(key, list);
    }

    /**
     * redis List数据结构 : 将值 value 插入到列表 key 当中，位于值 index之后。
     *
     * @param key   the key
     * @param index the index
     * @param value the value
     */
    public void listInsertValue(String key, long index, Object value) {
        opsForList().set(key, index, value);
    }

    /**
     * Set数据结构相关操作
     *
     * @return SetOperations
     */
    public SetOperations<String, Object> opsForSet() {
        return redisTemplate.opsForSet();
    }

    /**
     * 存储set集合类型数据
     *
     * @param key   key值
     * @param value value对象
     */
    public void setAdd(String key, Object... value) {
        this.opsForSet().add(key, value);
    }

    /**
     * 随机获取set集合中元素
     *
     * @param key key值
     * @return
     */
    public Object randomSetMember(String key) {
        return this.opsForSet().randomMember(key);
    }


    /**
     * 获取set集合
     *
     * @param key
     * @return
     */
    public Set<Object> getSetMember(String key) {
        return this.opsForSet().members(key);
    }

    /**
     * 移除指定set集合中的元素
     *
     * @param key   集合key
     * @param value 移除元素
     */
    public void removeSetMember(String key, Object... value) {
        redisTemplate.opsForSet().remove(key, value);
    }

    /**
     * 获取set集合的大小
     *
     * @param key
     * @return
     */
    public Long getSetSize(String key) {
        return redisTemplate.opsForSet().size(key);
    }

    /**
     * set里面是否包含成员
     *
     * @param key
     * @param value
     * @return
     */
    public Boolean isSetMember(String key, Object value) {
        return redisTemplate.opsForSet().isMember(key, value);
    }

    /**
     * ZSet数据结构相关操作
     *
     * @return ZSetOperations
     */
    public ZSetOperations<String, Object> opsForZSet() {
        return redisTemplate.opsForZSet();
    }


    /**
     * redis zSet 添加元素
     *
     * @param key
     * @param value
     * @param score
     */
    public Boolean zSetAdd(String key, Object value, double score) {
        return opsForZSet().add(key, value, score);
    }

    /**
     * 根据Score的范围查找值
     *
     * @param key
     * @param min
     * @param max
     * @return
     */
    public Set<Object> zSetRangeByScore(String key, double min, double max) {
        return opsForZSet().rangeByScore(key, min, max);
    }

    /**
     * 根据Score的范围删除值
     *
     * @param key
     * @param min
     * @param max
     */
    public void zSetRemRangeByScore(String key, double min, double max) {
        opsForZSet().removeRangeByScore(key, min, max);
    }

    /**
     * 升序删除一定范围的值
     *
     * @param key
     * @param start
     * @param end
     */
    public void zSetRemoveRange(String key, Long start, Long end) {
        opsForZSet().removeRange(key, start, end);
    }

    /**
     * 批量移除
     *
     * @param key
     * @param values
     */
    public void zSetRemove(String key, Object... values) {
        opsForZSet().remove(key, values);
    }

    /**
     * 根据key获取zSet的数量
     *
     * @param key
     */
    public Long zSetCard(String key) {
        return opsForZSet().zCard(key);
    }

    /**
     * 根据score倒序范围排列, start, end为偏移量,开始位移和结束位移
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Set<Object> zSetReverseRange(String key, Long start, Long end) {
        return opsForZSet().reverseRange(key, start, end);
    }

    /**
     * 根据Score升序范围排列, start, end为偏移量,开始位移和结束位移
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Set<Object> zSetRange(String key, Long start, Long end) {
        return opsForZSet().range(key, start, end);
    }

    /**
     * 修改单个score的值，策略:先删除该score，然后新加该值
     *
     * @param key
     * @param score
     */
    public void zSetModifyScoreSet(String key, Double score, Object value) {
        this.zSetRemRangeByScore(key, score, score);
        this.zSetAdd(key, value, score);
    }

    /**
     * 判断zSet中是否有值
     *
     * @param key
     * @param value
     * @return
     */
    public Boolean zSetIsMember(String key, Object value) {
        Long rank = opsForZSet().rank(key, value);
        return rank != null;
    }

    /**
     * 获取某个值对应的score
     *
     * @param key
     * @param value
     * @return
     */
    public Double zSetScore(String key, Object value) {
        return opsForZSet().score(key, value);
    }

    private byte[] rawKey(Object key) {

        if (key instanceof byte[]) {
            return (byte[]) key;
        }
        RedisSerializer<Object> redisSerializer = (RedisSerializer<Object>) redisTemplate.getKeySerializer();
        return redisSerializer.serialize(key);
    }

    private byte[] rawValue(Object value, RedisSerializer valueSerializer) {
        if (value instanceof byte[]) {
            return (byte[]) value;
        }

        return valueSerializer.serialize(value);
    }

    private List deserializeValues(List<byte[]> rawValues, RedisSerializer<Object> valueSerializer) {
        if (valueSerializer == null) {
            return rawValues;
        }
        return SerializationUtils.deserialize(rawValues, valueSerializer);
    }

    private Object deserializeValue(byte[] value, RedisSerializer<Object> valueSerializer) {
        if (valueSerializer == null) {
            return value;
        }
        return valueSerializer.deserialize(value);
    }
}


